home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / Audio dcmds / Audio CD dcmds.sit / Audio CD dcmds.π / play dcmd ƒ / cd.c next >
Text File  |  1995-07-02  |  9KB  |  357 lines
  1. // imWare
  2. // Wednesday, February 14, 1990
  3. // James Beninghaus
  4.  
  5. //#include    <ToolUtils.h>
  6. #include    <Memory.h>
  7. #include    <Errors.h>
  8. #include    "cd.h"
  9. #include "toolutils.h"
  10. pascal    Byte Decimal2BCD(Byte n) {
  11.     return ((n / 10) << 4) + (n % 10); 
  12. }
  13.  
  14. pascal    Byte BCD2Decimal(Byte n) {
  15.     return ((n >> 4) * 10) + (n & 0x0f);
  16. }
  17.  
  18. pascal    OSErr OpenCD(Byte CDDrive, short *ioRefNum) {
  19.  
  20.     auto    OSErr            osErr;
  21.     auto    short            ioRefNumTemp,
  22.                             CDDriveCount,
  23.                             SCSIID;
  24.     static    WhoIsThereRec    *pb;
  25.  
  26.     pb = (WhoIsThereRec *) NewPtrClear(sizeof (*pb));
  27.     osErr = MemError();
  28.     if (0 != pb && noErr == osErr) {
  29.         osErr = OpenDriver("\p.AppleCD", &ioRefNumTemp);
  30.         if (noErr == osErr) {
  31.             (*pb).ioRefNum        = ioRefNumTemp;
  32.             (*pb).csCode        = csWhoIsThere;
  33.             osErr = PBStatus((ParmBlkPtr)pb, false);
  34.             if (noErr == osErr) {
  35.                 CDDriveCount = 0;
  36.                 for (SCSIID = 0; SCSIID < 7; ++SCSIID) {
  37.                     if (BitTst(&(*pb).csParam.SCSIMask, 7 - SCSIID)) {
  38.                         ++CDDriveCount;
  39.                         if (CDDrive == CDDriveCount) {
  40.                             *ioRefNum = -(32 + SCSIID) - 1;
  41.                             DisposPtr((Ptr) pb);
  42.                             return noErr;
  43.                         }
  44.                     }
  45.                 }
  46.                 osErr = paramErr;
  47.             }
  48.         }
  49.         DisposPtr((Ptr) pb);
  50.     }
  51.     return osErr;
  52. }
  53.  
  54. pascal    OSErr EjectCD(short ioRefNum) {
  55.  
  56.     auto    OSErr            osErr;
  57.     auto    Str255            ioName;
  58.     static    HVolumeParam    *pb;
  59.     
  60.     pb = (HVolumeParam *) NewPtrClear(sizeof (*pb));
  61.     osErr = MemError();
  62.     if (0 != pb && noErr == osErr) {
  63.         (*pb).ioNamePtr    = ioName;
  64.         (*pb).ioVolIndex = 0;
  65.         do {
  66.             ++(*pb).ioVolIndex;
  67.             osErr = PBHGetVInfo((HParmBlkPtr)pb, false);
  68.             if (noErr != osErr) {
  69.                 DisposPtr((Ptr) pb);
  70.                 return osErr;
  71.             }
  72.         } while ((*pb).ioVDRefNum != ioRefNum);
  73.         osErr = PBEject((ParmBlkPtr)pb);
  74.         if (noErr == osErr)
  75.              osErr = PBUnmountVol((ParmBlkPtr)pb);
  76.         DisposPtr((Ptr) pb);
  77.     }
  78.     return osErr;
  79. }
  80.  
  81. pascal    OSErr ACurrInfo(short ioRefNum, Byte *currentTrack, Byte *discMinutes, Byte *discSeconds, Byte *discFrames)
  82. {
  83.     auto    OSErr            osErr;
  84.     static    ReadQRec        *pb;
  85.     Byte    mins;    
  86.  
  87.     pb = (ReadQRec *) NewPtrClear(sizeof (*pb));
  88.     osErr = MemError();
  89.     if (0 != pb && noErr == osErr) {
  90.         (*pb).ioRefNum             = ioRefNum;
  91.         (*pb).csCode            = csReadQ;
  92.         osErr = PBControl((ParmBlkPtr)pb, false);
  93.         if (noErr == osErr) {
  94.             *currentTrack = BCD2Decimal((*pb).csParam.currentTrack);
  95.             *discMinutes = BCD2Decimal((*pb).csParam.addrFromDiscStart.minutes);
  96.             *discSeconds = BCD2Decimal((*pb).csParam.addrFromDiscStart.seconds);
  97.             *discFrames = BCD2Decimal((*pb).csParam.addrFromDiscStart.frames);
  98.             osErr = (*pb).ioResult;
  99.         }
  100.         DisposPtr((Ptr)pb);
  101.     }
  102.     return osErr;    
  103. }
  104.  
  105. pascal    OSErr ACurrTrackInfo(short ioRefNum, Byte *currentTrack, Byte *discMinutes, Byte *discSeconds, Byte *discFrames)
  106. {
  107.     auto    OSErr            osErr;
  108.     static    ReadQRec        *pb;
  109.     Byte    mins;    
  110.  
  111.     pb = (ReadQRec *) NewPtrClear(sizeof (*pb));
  112.     osErr = MemError();
  113.     if (0 != pb && noErr == osErr) {
  114.         (*pb).ioRefNum             = ioRefNum;
  115.         (*pb).csCode            = csReadQ;
  116.         osErr = PBControl((ParmBlkPtr)pb, false);
  117.         if (noErr == osErr) {
  118.             *currentTrack = BCD2Decimal((*pb).csParam.currentTrack);
  119.             *discMinutes = BCD2Decimal((*pb).csParam.addrFromTrackStart.minutes);
  120.             *discSeconds = BCD2Decimal((*pb).csParam.addrFromTrackStart.seconds);
  121.             *discFrames = BCD2Decimal((*pb).csParam.addrFromTrackStart.frames);
  122.             osErr = (*pb).ioResult;
  123.         }
  124.         DisposPtr((Ptr)pb);
  125.     }
  126.     return osErr;    
  127. }
  128.  
  129.  
  130. pascal    OSErr APlay(short ioRefNum, Byte startTrack, Byte playMode) {
  131.  
  132.     auto    OSErr            osErr;
  133.     static    APlayRec        *pb;    
  134.  
  135.     pb = (APlayRec *) NewPtrClear(sizeof (*pb));
  136.     osErr = MemError();
  137.     if (0 != pb && noErr == osErr) {
  138.         (*pb).ioRefNum             = ioRefNum;
  139.         (*pb).csCode            = csAPlay;
  140.         (*pb).csParam.type        = TRACKADDR;
  141.         (*pb).csParam.addr[3]    = Decimal2BCD(startTrack);
  142.         (*pb).csParam.startStop    = START;
  143.         (*pb).csParam.fill        = 0;
  144.         (*pb).csParam.playMode    = playMode;
  145.         osErr = PBControl((ParmBlkPtr)pb, false);
  146.         DisposPtr((Ptr) pb);
  147.     }
  148.     return osErr;
  149. }
  150.  
  151. pascal    OSErr AStop(short ioRefNum, Byte stopTrack) {
  152.  
  153.     auto    OSErr            osErr;
  154.     static    AStopRec        *pb;    
  155.  
  156.     pb = (AStopRec *) NewPtrClear(sizeof (*pb));
  157.     osErr = MemError();
  158.     if (0 != pb && noErr == osErr) {
  159.         (*pb).ioRefNum             = ioRefNum;
  160.         (*pb).csCode            = csAStop;
  161.         (*pb).csParam.type        = 0 == stopTrack ? BLOCKADDR : TRACKADDR; 
  162.         (*pb).csParam.addr[3]    = Decimal2BCD(stopTrack);
  163.         osErr = PBControl((ParmBlkPtr)pb, false);
  164.         DisposPtr((Ptr) pb);
  165.     }
  166.     return osErr;
  167. }
  168.  
  169. pascal    OSErr APause(short ioRefNum, Long state) { 
  170.  
  171.     auto    OSErr            osErr;
  172.     static    APauseRec        *pb;
  173.  
  174.     pb = (APauseRec *) NewPtrClear(sizeof (*pb));
  175.     osErr = MemError();
  176.     if (0 != pb && noErr == osErr) {
  177.         (*pb).ioRefNum            = ioRefNum;
  178.         (*pb).csCode            = csAPause;
  179.         (*pb).csParam.state        = state;
  180.         osErr = PBControl((ParmBlkPtr)pb, false);
  181.         DisposPtr((Ptr) pb);
  182.     }
  183.     return osErr;
  184. }
  185.  
  186. pascal    OSErr AScan(short ioRefNum, Byte startMin, Byte startSec, Byte startFrame, Byte direction)
  187. {
  188.     auto    OSErr            osErr;
  189.     static    AScanRec        *pb;    
  190.  
  191.     pb = (AScanRec *) NewPtrClear(sizeof (*pb));
  192.     osErr = MemError();
  193.     if (0 != pb && noErr == osErr) {
  194.         (*pb).ioRefNum             = ioRefNum;
  195.         (*pb).csCode            = csAScan;
  196.         (*pb).csParam.type        = MSFADDR;
  197.         (*pb).csParam.addr[1]    = Decimal2BCD(startMin);
  198.         (*pb).csParam.addr[2]    = Decimal2BCD(startSec);
  199.         (*pb).csParam.addr[3]    = Decimal2BCD(startFrame);
  200.         (*pb).csParam.directionFlag    = direction;
  201.         (*pb).csParam.fill        = 0;
  202.         osErr = PBControl((ParmBlkPtr)pb, false);
  203.         DisposPtr((Ptr) pb);
  204.     }
  205.     return osErr;
  206. }
  207.  
  208.  
  209. pascal    OSErr TrackCount(short ioRefNum, Byte *stopTrack) {
  210.  
  211.     auto    OSErr            osErr;
  212.     static    ReadTOCRec        *pb;
  213.  
  214.     pb = (ReadTOCRec *) NewPtrClear(sizeof (*pb));
  215.     osErr = MemError();
  216.     if (0 != pb && noErr == osErr) {
  217.         (*pb).ioRefNum            = ioRefNum;
  218.         (*pb).csCode            = csReadTOC;
  219.         (*pb).csParam.type        = 1;
  220.         osErr = PBControl((ParmBlkPtr)pb, false);
  221.         if (noErr == osErr) {
  222.             *stopTrack            = BCD2Decimal((*pb).csParam.addr[1]);
  223.         }
  224.         DisposPtr((Ptr) pb);
  225.     }
  226.     return osErr;
  227. }
  228.  
  229. pascal    OSErr TrackInfo(short ioRefNum, Byte track, Byte *cntlField, Byte *minutes, Byte *seconds, Byte *frames) {
  230.  
  231.     auto    OSErr            osErr;
  232.     static    ReadTOCRec        *pb;
  233.     
  234.     pb = (ReadTOCRec *) NewPtrClear(sizeof (*pb));
  235.     osErr = MemError();
  236.     if (0 != pb && noErr == osErr) {
  237.         (*pb).ioRefNum                    = ioRefNum;
  238.         (*pb).csCode                    = csReadTOC;
  239.         (*pb).csParam.type                = 3;
  240.         (*pb).csParam.buffer.data        = (Long) NewPtrClear(sizeof (StartAddrRec));
  241.         osErr = MemError();
  242.         if (0 != (*pb).csParam.buffer.data && noErr == osErr) {
  243.             (*pb).csParam.buffer.length        = sizeof(StartAddrRec);
  244.             (*pb).csParam.buffer.track        = Decimal2BCD(track);
  245.             osErr = PBControl((ParmBlkPtr)pb, false);
  246.             if (noErr == osErr) {
  247.                 *cntlField         = (*(StartAddrRec *)(*pb).csParam.buffer.data).cntlField;
  248.                 *minutes         = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).minutes);
  249.                 *seconds        = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).seconds);
  250.                 *frames            = BCD2Decimal((*(StartAddrRec *)(*pb).csParam.buffer.data).frames);
  251.             }
  252.             DisposPtr((Ptr) (*pb).csParam.buffer.data);
  253.         }
  254.         DisposPtr((Ptr) pb);
  255.     }
  256.     return osErr;
  257. }
  258.  
  259. pascal    OSErr ATrkSearch(short ioRefNum, Byte track, Byte playFlag, Byte playMode) {
  260.  
  261.     auto    OSErr            osErr;
  262.     static    ATrkSearchRec    *pb;    
  263.  
  264.     pb = (ATrkSearchRec *) NewPtrClear(sizeof (*pb));
  265.     osErr = MemError();
  266.     if (0 != pb && noErr == osErr) {
  267.         (*pb).ioRefNum             = ioRefNum;
  268.         (*pb).csCode            = csATrkSearch;
  269.         (*pb).csParam.type        = TRACKADDR;
  270.         (*pb).csParam.addr[3]    = Decimal2BCD(track);
  271.         (*pb).csParam.playFlag    = playFlag;
  272.         (*pb).csParam.playMode    = playMode;
  273.         osErr = PBControl((ParmBlkPtr)pb, false);
  274.         DisposPtr((Ptr) pb);
  275.     }
  276.     return osErr;
  277. }
  278.  
  279. pascal    OSErr AStatus(short ioRefNum, Byte *audioStatus, Byte *playMode, Byte *cntlField, Byte *minutes, Byte *seconds, Byte *frames) {
  280.  
  281.     auto    OSErr            osErr;
  282.     static    AStatusRec        *pb;
  283.  
  284.     pb = (AStatusRec *) NewPtrClear(sizeof (*pb));
  285.     osErr = MemError();
  286.     if (0 != pb && noErr == osErr) {
  287.         (*pb).ioRefNum                = ioRefNum;
  288.         (*pb).csCode                = csAStatus;
  289.         osErr = PBControl((ParmBlkPtr)pb, false);
  290.         if (noErr == osErr) {
  291.             *audioStatus        = (*pb).csParam.audioStatus;
  292.             *playMode            = (*pb).csParam.playMode;
  293.             *cntlField            = (*pb).csParam.cntlField;
  294.             *minutes            = BCD2Decimal((*pb).csParam.minutes);
  295.             *seconds            = BCD2Decimal((*pb).csParam.seconds);
  296.             *frames                = BCD2Decimal((*pb).csParam.frames);
  297.         }
  298.         DisposPtr((Ptr) pb);
  299.     }
  300.     return osErr;
  301. }
  302.  
  303. pascal OSErr AGetVolume(short ioRefNum, short *volume)
  304. {
  305.  
  306.     auto    OSErr            osErr;
  307.     static    AVolumeRec        *pb;
  308.  
  309.     pb = ( AVolumeRec *) NewPtrClear(sizeof (*pb));
  310.     osErr = MemError();
  311.     if (0 != pb && noErr == osErr) {
  312.         (*pb).ioRefNum                = ioRefNum;
  313.         (*pb).csCode                = csAGetVolume;
  314.         osErr = PBControl((ParmBlkPtr)pb, false);
  315.         if (noErr == osErr) {
  316.             *volume        = ((*pb).csParam.leftChannel + (*pb).csParam.rightChannel) /2;
  317.         }
  318.         DisposPtr((Ptr) pb);
  319.     }
  320.     return osErr;
  321.  
  322. }
  323.  
  324. pascal OSErr ASetVolume(short ioRefNum, short volume)
  325. {
  326.     auto    OSErr            osErr;
  327.     static    AVolumeRec        *pb;
  328.  
  329.     pb = (AVolumeRec *) NewPtrClear(sizeof (*pb));
  330.     osErr = MemError();
  331.     if (0 != pb && noErr == osErr) {
  332.         (*pb).ioRefNum                = ioRefNum;
  333.         (*pb).csCode                = csASetVolume;
  334.         (*pb).csParam.leftChannel  = volume;
  335.         (*pb).csParam.rightChannel  = volume;
  336.         osErr = PBControl((ParmBlkPtr)pb, false);
  337.         DisposPtr((Ptr) pb);
  338.     }
  339.     return osErr;
  340. }
  341.  
  342. pascal Boolean    DiscInDrive(short ioRefNum)
  343. {
  344.     auto    OSErr            osErr;
  345.     static    AVolumeRec        *pb;
  346.  
  347.     pb = (AVolumeRec *) NewPtrClear(sizeof (*pb));
  348.     osErr = MemError();
  349.     if (0 != pb && noErr == osErr) {
  350.         (*pb).ioRefNum                = ioRefNum;
  351.         (*pb).csCode                = csVerifyTheDisc;
  352.         osErr = PBControl((ParmBlkPtr)pb, false);
  353.         DisposPtr((Ptr) pb);
  354.     }
  355.     return (osErr == noErr);
  356. }
  357.